package com.hugesoft.utils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.RectF;
import android.os.Build;
import android.util.Log;

import com.hugesoft.jxgs.R;
import com.hugesoft.logic.managers.common.Constans;


public class BitmapUtil {
	
	public static String saveBitmap(Bitmap bitmap,String filepath){
		if (bitmap==null||bitmap.isRecycled()||filepath==null||filepath.trim().equals("")) {
			return null;
		}
		FileOutputStream fos = null;
		File file = new File(filepath);
		try {
			file.createNewFile();
			fos = new FileOutputStream(file);
			bitmap.compress(CompressFormat.JPEG, 100, fos);
			fos.flush();
			fos.close();
			return filepath;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	public static Bitmap createMutableBitmap(Bitmap source, int x, int y,
			int width, int height, Matrix m, boolean filter) {
		if (source == null || source.isRecycled()) {
			return null;
		}
		if (x < 0) {
			throw new IllegalArgumentException("x must be >= 0");
		}
		if (y < 0) {
			throw new IllegalArgumentException("y must be >= 0");
		}

		if (width <= 0) {
			throw new IllegalArgumentException("width must be > 0");
		}
		if (height <= 0) {
			throw new IllegalArgumentException("height must be > 0");
		}

		if (x + width > source.getWidth()) {
			throw new IllegalArgumentException(
					"x + width must be <= bitmap.width()");
		}
		if (y + height > source.getHeight()) {
			throw new IllegalArgumentException(
					"y + height must be <= bitmap.height()");
		}

		int neww = width;
		int newh = height;
		Canvas canvas = new Canvas();
		Bitmap bitmap;
		Paint paint;

		Rect srcR = new Rect(x, y, x + width, y + height);
		RectF dstR = new RectF(0, 0, width, height);

		Config newConfig = Config.ARGB_8888;
		/*
		 * final Config config = source.getConfig(); // GIF files generate null
		 * configs, assume ARGB_8888 if (config != null) { switch (config) {
		 * case RGB_565: newConfig = Config.RGB_565; break; case ALPHA_8:
		 * newConfig = Config.ALPHA_8; break; //noinspection deprecation case
		 * ARGB_4444: case ARGB_8888: default: newConfig = Config.ARGB_8888;
		 * break; } }
		 */

		if (m == null || m.isIdentity()) {
			try {
				bitmap = Bitmap.createBitmap(neww, newh, newConfig);
			} catch (OutOfMemoryError e2) {
				return null;
			}
			paint = null; // not needed
		} else {
			final boolean transformed = !m.rectStaysRect();

			RectF deviceR = new RectF();
			m.mapRect(deviceR, dstR);

			neww = Math.round(deviceR.width());
			newh = Math.round(deviceR.height());

			/*
			 * bitmap = createBitmap(neww, newh, transformed ? Config.ARGB_8888
			 * : newConfig, transformed || source.hasAlpha());
			 */
			if (neww <= 0 || newh <= 0) {
				return null;
			}
			try {
				bitmap = Bitmap.createBitmap(neww, newh,
						transformed ? Config.ARGB_8888 : newConfig);
			} catch (OutOfMemoryError e1) {
				return null;
			} catch (Exception e) {
				return null;
			}

			canvas.translate(-deviceR.left, -deviceR.top);
			canvas.concat(m);

			paint = new Paint();
			paint.setFilterBitmap(filter);
			if (transformed) {
				paint.setAntiAlias(true);
			}
		}
		if (bitmap == null || bitmap.isRecycled()) {
			return null;
		}
		if (source == null || source.isRecycled()) {
			return null;
		}
		// The new bitmap was created from a known bitmap source so assume that
		// they use the same density
		bitmap.setDensity(source.getDensity());

		canvas.setBitmap(bitmap);
		canvas.drawBitmap(source, srcR, dstR, paint);

		if (Build.VERSION.SDK_INT >= 14) {
			// 要大于4.0，在低版本中Canvas.setBitmap，如果传一个null，会crash
			canvas.setBitmap(null);
		}

		return bitmap;
	}
	public static Bitmap loadBitmap(String path){
		BitmapFactory.Options options = new BitmapFactory.Options();
		options.inSampleSize = 3;
		Bitmap result = null;
		try {
			result = BitmapFactory.decodeFile(path,options);
		} catch (OutOfMemoryError e) {
			System.gc();
			try {
				result = BitmapFactory.decodeFile(path,options);
			} catch (OutOfMemoryError e2) {
				// TODO: handle exception
			}
		}
		return result;
	}
	public static Bitmap comp(Bitmap image,float ww,float hh) {
		
		ByteArrayOutputStream baos = new ByteArrayOutputStream();		
		image.compress(Bitmap.CompressFormat.JPEG, 80, baos);
		if( baos.toByteArray().length / 1024>1024) {//判断如果图片大于1M,进行压缩避免在生成图片（BitmapFactory.decodeStream）时溢出	
			baos.reset();//重置baos即清空baos
			image.compress(Bitmap.CompressFormat.JPEG, 50, baos);//这里压缩50%，把压缩后的数据存放到baos中
		}
		ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
		BitmapFactory.Options newOpts = new BitmapFactory.Options();
		//开始读入图片，此时把options.inJustDecodeBounds 设回true了
		newOpts.inJustDecodeBounds = true;
		Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
		newOpts.inJustDecodeBounds = false;
		int w = newOpts.outWidth;
		int h = newOpts.outHeight;
		//缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
		int be = 1;//be=1表示不缩放
		if (w > h && w > ww) {//如果宽度大的话根据宽度固定大小缩放
			be = (int) (newOpts.outWidth / ww);
		} else if (w < h && h > hh) {//如果高度高的话根据宽度固定大小缩放
			be = (int) (newOpts.outHeight / hh);
		}
		if (be <= 0)
			be = 1;
		newOpts.inSampleSize = be;//设置缩放比例
		//重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
		isBm = new ByteArrayInputStream(baos.toByteArray());
		bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
		return compressImage(bitmap);//压缩好比例大小后再进行质量压缩
	}
	private static Bitmap compressImage(Bitmap image) {

		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		image.compress(Bitmap.CompressFormat.JPEG, 80, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
		int options = 100;
		while ( baos.toByteArray().length / 1024>100) {	//循环判断如果压缩后图片是否大于100kb,大于继续压缩		
			baos.reset();//重置baos即清空baos
			image.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中
			options -= 10;//每次都减少10
		}
		ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());//把压缩后的数据baos存放到ByteArrayInputStream中
		Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);//把ByteArrayInputStream数据生成图片
		image.recycle();
		image = null;
		System.gc();
		return bitmap;
	}
	
	public static byte[] loadBitmapToByteArray(String path)
	{
		return Bitmap2Bytes(BitmapUtil.comp(loadBitmap(path), 400f, 400f));
	}
	
	private static byte[] Bitmap2Bytes(Bitmap bm){
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		bm.compress(Bitmap.CompressFormat.PNG, 10, baos);
		return baos.toByteArray();
	}
}
